import { intersectionWith, isEqual, isString, mergeWith, unionWith } from 'lodash-es';
import { type CSSProperties } from 'vue';
import { unref } from 'vue';

import { useMessage } from '@/hooks/useMessage';
import { useI18n } from '@/locale/index';
import pagesConfig from '@/pages.json';
import { isArray, isObject } from '@/utils/is';

import { isMpWeixin } from './platform';

const { pages, subPackages, tabBar = { list: [] } } = { ...pagesConfig };

export const getLastPage = () => {
  // getCurrentPages() 至少有1个元素，所以不再额外判断
  // const lastPage = getCurrentPages().at(-1)
  // 上面那个在低版本安卓中打包会报错，所以改用下面这个【虽然我加了 src/interceptions/prototype.ts，但依然报错】
  const pages = getCurrentPages();
  return pages[pages.length - 1];
};

/** 判断当前页面是否是 tabbar 页  */
export const getIsTabbar = () => {
  try {
    const lastPage = getLastPage();
    const currPath = lastPage?.route;

    return Boolean(tabBar?.list?.some((item) => item.pagePath === currPath));
  } catch {
    return false;
  }
};

/**
 * 判断指定页面是否是 tabbar 页
 * @param path 页面路径
 * @returns true: 是 tabbar 页 false: 不是 tabbar 页
 */
export const isTableBar = (path: string) => {
  if (!tabBar) {
    return false;
  }
  if (!tabBar.list.length) {
    // 通常有 tabBar 的话，list 不能有空，且至少有2个元素，这里其实不用处理
    return false;
  }
  // 这里需要处理一下 path，因为 tabBar 中的 pagePath 是不带 /pages 前缀的
  if (path.startsWith('/')) {
    path = path.substring(1);
  }
  return !!tabBar.list.find((e) => e.pagePath === path);
};

/**
 * 获取当前页面路由的 path 路径和 redirectPath 路径
 * path 如 '/pages/login/index'
 * redirectPath 如 '/pages/demo/base/route-interceptor'
 */
export const currRoute = () => {
  const lastPage = getLastPage();
  const currRoute = (lastPage as any).$page;
  // console.log('lastPage.$page:', currRoute)
  // console.log('lastPage.$page.fullpath:', currRoute.fullPath)
  // console.log('lastPage.$page.options:', currRoute.options)
  // console.log('lastPage.options:', (lastPage as any).options)
  // 经过多端测试，只有 fullPath 靠谱，其他都不靠谱
  const { fullPath } = currRoute as { fullPath: string };
  // console.log(fullPath)
  // eg: /pages/login/index?redirect=%2Fpages%2Fdemo%2Fbase%2Froute-interceptor (小程序)
  // eg: /pages/login/index?redirect=%2Fpages%2Froute-interceptor%2Findex%3Fname%3Dfeige%26age%3D30(h5)
  return getUrlObj(fullPath);
};

const ensureDecodeURIComponent = (url: string) => {
  if (url.startsWith('%')) {
    return ensureDecodeURIComponent(decodeURIComponent(url));
  }
  return url;
};

/**
 * 解析 url 得到 path 和 query
 * 比如输入url: /pages/login/index?redirect=%2Fpages%2Fdemo%2Fbase%2Froute-interceptor
 * 输出: {path: /pages/login/index, query: {redirect: /pages/demo/base/route-interceptor}}
 */
export const getUrlObj = (url: string) => {
  const [path, queryStr] = url.split('?');
  // console.log(path, queryStr)

  if (!queryStr) {
    return {
      path,
      query: {},
    };
  }
  const query: Record<string, string> = {};
  queryStr.split('&').forEach((item) => {
    const [key, value] = item.split('=');
    // console.log(key, value)
    query[key] = ensureDecodeURIComponent(value); // 这里需要统一 decodeURIComponent 一下，可以兼容h5和微信y
  });
  return { path, query };
};

/**
 * 得到所有的需要登录的 pages，包括主包和分包的
 * 这里设计得通用一点，可以传递 key 作为判断依据，默认是 needLogin, 与 route-block 配对使用
 * 如果没有传 key，则表示所有的 pages，如果传递了 key, 则表示通过 key 过滤
 */
export const getAllPages = (key = 'needLogin') => {
  // 这里处理主包
  const mainPages = [
    ...pages
      .filter((page) => !key || page[key])
      .map((page) => ({
        ...page,
        path: `/${page.path}`,
      })),
  ];
  // 这里处理分包
  const subPages: any[] = [];
  subPackages.forEach((subPageObj) => {
    // console.log(subPageObj)
    const { root } = subPageObj;

    subPageObj.pages
      .filter((page) => !key || page[key])
      .forEach((page: { path: string } & Record<string, any>) => {
        subPages.push({
          ...page,
          path: `/${root}/${page.path}`,
        });
      });
  });
  const result = [...mainPages, ...subPages];
  // console.log(`getAllPages by ${key} result: `, result)
  return result;
};

/**
 * 得到所有的需要登录的 pages，包括主包和分包的
 * 只得到 path 数组
 */
export const getNeedLoginPages = (): string[] => getAllPages('needLogin').map((page) => page.path);

/**
 * 得到所有的需要登录的 pages，包括主包和分包的
 * 只得到 path 数组
 */
export const needLoginPages: string[] = getAllPages('needLogin').map((page) => page.path);

/**
 * 根据微信小程序当前环境，判断应该获取的 baseUrl
 */
export const getEnvBaseUrl = () => {
  // 请求基准地址
  let baseUrl = import.meta.env.VITE_SERVER_BASEURL;

  // 微信小程序端环境区分
  if (isMpWeixin) {
    const {
      miniProgram: { envVersion },
    } = uni.getAccountInfoSync();

    switch (envVersion) {
      case 'develop':
        baseUrl = import.meta.env.VITE_SERVER_BASEURL__WEIXIN_DEVELOP || baseUrl;
        break;
      case 'trial':
        baseUrl = import.meta.env.VITE_SERVER_BASEURL__WEIXIN_TRIAL || baseUrl;
        break;
      case 'release':
        baseUrl = import.meta.env.VITE_SERVER_BASEURL__WEIXIN_RELEASE || baseUrl;
        break;
    }
  }

  return baseUrl;
};

/**
 * 根据微信小程序当前环境，判断应该获取的 UPLOAD_BASEURL
 */
export const getEnvBaseUploadUrl = () => {
  // 请求基准地址
  let baseUploadUrl = import.meta.env.VITE_UPLOAD_BASEURL;

  // 微信小程序端环境区分
  if (isMpWeixin) {
    const {
      miniProgram: { envVersion },
    } = uni.getAccountInfoSync();

    switch (envVersion) {
      case 'develop':
        baseUploadUrl = import.meta.env.VITE_UPLOAD_BASEURL__WEIXIN_DEVELOP || baseUploadUrl;
        break;
      case 'trial':
        baseUploadUrl = import.meta.env.VITE_UPLOAD_BASEURL__WEIXIN_TRIAL || baseUploadUrl;
        break;
      case 'release':
        baseUploadUrl = import.meta.env.VITE_UPLOAD_BASEURL__WEIXIN_RELEASE || baseUploadUrl;
        break;
    }
  }

  return baseUploadUrl;
};

/**
 * Recursively merge two objects.
 * 递归合并两个对象。
 *
 * @param source The source object to merge from. 要合并的源对象。
 * @param target The target object to merge into. 目标对象，合并后结果存放于此。
 * @param mergeArrays How to merge arrays. Default is "replace".
 *        如何合并数组。默认为replace。
 *        - "union": Union the arrays. 对数组执行并集操作。
 *        - "intersection": Intersect the arrays. 对数组执行交集操作。
 *        - "concat": Concatenate the arrays. 连接数组。
 *        - "replace": Replace the source array with the target array. 用目标数组替换源数组。
 * @returns The merged object. 合并后的对象。
 */
export function deepMerge<T extends object | null | undefined, U extends object | null | undefined>(
  source: T,
  target: U,
  mergeArrays: 'union' | 'intersection' | 'concat' | 'replace' = 'replace',
): T & U {
  if (!target) {
    return source as T & U;
  }
  if (!source) {
    return target as T & U;
  }
  return mergeWith({}, source, target, (sourceValue, targetValue) => {
    if (isArray(targetValue) && isArray(sourceValue)) {
      switch (mergeArrays) {
        case 'union':
          return unionWith(sourceValue, targetValue, isEqual);
        case 'intersection':
          return intersectionWith(sourceValue, targetValue, isEqual);
        case 'concat':
          return sourceValue.concat(targetValue);
        case 'replace':
          return targetValue;
        default:
          throw new Error(`Unknown merge array strategy: ${mergeArrays as string}`);
      }
    }
    if (isObject(targetValue) && isObject(sourceValue)) {
      return deepMerge(sourceValue, targetValue, mergeArrays);
    }
    return undefined;
  });
}

/**
 * Add the object as a parameter to the URL
 * @param baseUrl url
 * @param obj
 * @returns {string}
 * eg:
 *  let obj = {a: '3', b: '4', c: ['1','2']}
 *  setObjToUrlParams('www.baidu.com', obj)
 *  ==>www.baidu.com?a=3&b=4&c=1,2
 */
export function setObjToUrlParams(baseUrl: string, obj: any): string {
  let parameters = '';
  for (const key in obj) {
    const value = obj[key];
    if (Array.isArray(value)) {
      parameters += `${key}=${encodeURIComponent(value.join(','))}&`;
    } else {
      parameters += `${key}=${encodeURIComponent(value)}&`;
    }
  }
  parameters = parameters.replace(/&$/, '');
  return /\?$/.test(baseUrl) ? baseUrl + parameters : baseUrl.replace(/\/?$/, '?') + parameters;
}

// dynamic use hook props
export function getDynamicProps<T extends Record<string, unknown>, U>(props: T): Partial<U> {
  const ret: Recordable = {};

  Object.keys(props).forEach((key) => {
    ret[key] = unref((props as Recordable)[key]);
  });

  return ret as Partial<U>;
}

/** 移除 undefined 属性 */
export function rmUndefinedProps<T>(obj: T): T {
  const cleanObj: T = {} as T;
  for (const key in obj) {
    if (obj[key] !== undefined) {
      cleanObj[key] = obj[key];
    }
  }
  return cleanObj;
}

/** 获取随机元素 */
export function getRandomElement<T>(array: T[]) {
  return array[Math.floor(Math.random() * array.length)];
}

/**
 * 将短横线链接转换为驼峰命名
 * @param word 需要转换的短横线链接
 * @returns 转换后的驼峰命名字符串
 */
export function camelCase(word: string): string {
  if (!word) {
    return word;
  }
  return word
    .split('-')
    .map((word, index) => {
      if (index === 0) {
        return word;
      }
      return word.charAt(0).toUpperCase() + word.slice(1);
    })
    .join('');
}

/**
 * 打开链接
 * @param href 链接地址
 * @param type 地址类型
 */
export function openHref(href: string, type: 'http' | 'mail' | 'tel' = 'http') {
  if (!href && !isString(href)) {
    return;
  }
  const { modal } = useMessage();
  const { t } = useI18n();
  const mailto = 'mailto:';
  const tel = 'tel:';
  const isMail = href.toLowerCase().startsWith(mailto) || type === 'mail';
  const isTel = href.toLowerCase().startsWith(tel) || type === 'tel';
  let url = href.replace(/^mailto:+/, '').replace(/^tel:+/, ''); // 去除开头指定符号
  if (isMail) {
    url = `${mailto}${url}`;
  } else if (isTel) {
    url = `${tel}${url}`;
  }
  // #ifdef APP-PLUS
  if (isTel) {
    uni.makePhoneCall({
      phoneNumber: url.replace(/^tel:+/, ''), // 去除开头 tel: 符号
    });
  } else {
    plus.runtime.openURL(url);
  }
  // #endif
  // #ifdef H5
  window.open(url);
  // #endif
  // #ifdef MP
  modal
    .confirm({
      title: t('common.warmReminder'),
      content: href,
      confirmText: t('common.copy'),
      zIndex: 999999999,
    })
    .then(() => {
      uni.setClipboardData({
        data: href,
      });
    })
    .finally(() => {
      modal.close();
    });
  // #endif
}

/**
 * 将 Style 样式对象转为字符串表现形式
 * @param style 样式对象
 * @returns 样式对象的字符串表现形式
 */
export function styleToString(style: CSSProperties): string {
  const string = Object.keys(style)
    .map((key) => `${key}: ${style[key]};`)
    .join(' ');
  return string;
}
